home *** CD-ROM | disk | FTP | other *** search
/ Mac Easy 2010 May / Mac Life Ubuntu.iso / casper / filesystem.squashfs / usr / lib / gedit-2 / plugins / snippets / Placeholder.pyc (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2009-04-20  |  21.0 KB  |  658 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.6)
  3.  
  4. import traceback
  5. import re
  6. import os
  7. import sys
  8. import signal
  9. import select
  10. import locale
  11. import subprocess
  12. from SubstitutionParser import SubstitutionParser
  13. import gobject
  14. from Helper import *
  15.  
  16. class Placeholder:
  17.     
  18.     def __init__(self, view, tabstop, defaults, begin):
  19.         self.ok = True
  20.         self.done = False
  21.         self.buf = view.get_buffer()
  22.         self.view = view
  23.         self.has_references = False
  24.         self.mirrors = []
  25.         self.leave_mirrors = []
  26.         self.tabstop = tabstop
  27.         self.set_default(defaults)
  28.         self.prev_contents = self.default
  29.         self.set_mark_gravity()
  30.         if begin:
  31.             self.begin = self.buf.create_mark(None, begin, self.mark_gravity[0])
  32.         else:
  33.             self.begin = None
  34.         self.end = None
  35.  
  36.     
  37.     def __str__(self):
  38.         return '%s (%s)' % (str(self.__class__), str(self.default))
  39.  
  40.     
  41.     def set_mark_gravity(self):
  42.         self.mark_gravity = [
  43.             True,
  44.             False]
  45.  
  46.     
  47.     def set_default(self, defaults):
  48.         if not defaults:
  49.             self.default = None
  50.             return None
  51.         for d in defaults:
  52.             d = self.expand_environment(d)
  53.             if d != '':
  54.                 self.default = d
  55.                 return None
  56.         
  57.         self.default = None
  58.  
  59.     
  60.     def literal(self, s):
  61.         return repr(s)
  62.  
  63.     
  64.     def format_environment(self, s):
  65.         return s
  66.  
  67.     
  68.     def re_environment(self, m):
  69.         if m.group(1) or m.group(2) not in os.environ:
  70.             return '$' + m.group(2)
  71.         return self.format_environment(os.environ[m.group(2)])
  72.  
  73.     
  74.     def expand_environment(self, text):
  75.         if not text:
  76.             return text
  77.         return re.sub('(\\\\)?\\$([A-Z_]+)', self.re_environment, text)
  78.  
  79.     
  80.     def get_iter(self, mark):
  81.         if mark and not mark.get_deleted():
  82.             return self.buf.get_iter_at_mark(mark)
  83.         return None
  84.  
  85.     
  86.     def begin_iter(self):
  87.         return self.get_iter(self.begin)
  88.  
  89.     
  90.     def end_iter(self):
  91.         return self.get_iter(self.end)
  92.  
  93.     
  94.     def run_last(self, placeholders):
  95.         begin = self.begin_iter()
  96.         self.end = self.buf.create_mark(None, begin, self.mark_gravity[1])
  97.         if self.default:
  98.             insert_with_indent(self.view, begin, self.default, False, self)
  99.         
  100.  
  101.     
  102.     def remove(self, force = False):
  103.         if self.begin and not self.begin.get_deleted():
  104.             self.buf.delete_mark(self.begin)
  105.         
  106.         if self.end and not self.end.get_deleted():
  107.             self.buf.delete_mark(self.end)
  108.         
  109.  
  110.     
  111.     def enter(self):
  112.         if not (self.begin) or self.begin.get_deleted():
  113.             return None
  114.         self.buf.move_mark(self.buf.get_insert(), self.begin_iter())
  115.         if self.end:
  116.             self.buf.move_mark(self.buf.get_selection_bound(), self.end_iter())
  117.         else:
  118.             self.buf.move_mark(self.buf.get_selection_bound(), self.begin_iter())
  119.  
  120.     
  121.     def get_text(self):
  122.         if self.begin and self.end:
  123.             biter = self.begin_iter()
  124.             eiter = self.end_iter()
  125.             if biter and eiter:
  126.                 return self.buf.get_text(self.begin_iter(), self.end_iter())
  127.             return ''
  128.         self.end
  129.         return ''
  130.  
  131.     
  132.     def add_mirror(self, mirror, onleave = False):
  133.         mirror.has_references = True
  134.         if onleave:
  135.             self.leave_mirrors.append(mirror)
  136.         else:
  137.             self.mirrors.append(mirror)
  138.  
  139.     
  140.     def set_text(self, text):
  141.         if self.begin.get_deleted() or self.end.get_deleted():
  142.             return None
  143.         self.buf.begin_user_action()
  144.         begin = self.begin_iter()
  145.         self.buf.delete(begin, self.end_iter())
  146.         insert_with_indent(self.view, begin, text, True, self)
  147.         self.buf.end_user_action()
  148.         self.update_contents()
  149.  
  150.     
  151.     def update_contents(self):
  152.         prev = self.prev_contents
  153.         self.prev_contents = self.get_text()
  154.         if prev != self.get_text():
  155.             for mirror in self.mirrors:
  156.                 if not mirror.update(self):
  157.                     return None
  158.             
  159.         
  160.  
  161.     
  162.     def update_leave_mirrors(self):
  163.         for mirror in self.leave_mirrors:
  164.             if not mirror.update(self):
  165.                 return None
  166.         
  167.  
  168.     
  169.     def leave(self):
  170.         self.update_leave_mirrors()
  171.  
  172.     
  173.     def find_mirrors(self, text, placeholders):
  174.         mirrors = []
  175.         while True:
  176.             m = re.search('(\\\\)?\\$(?:{([0-9]+)}|([0-9]+))', text)
  177.             if not m:
  178.                 break
  179.             
  180.             if m.group(1):
  181.                 text = text[m.end():]
  182.                 continue
  183.             
  184.             if not m.group(2):
  185.                 pass
  186.             tabstop = int(m.group(3))
  187.             if tabstop in placeholders:
  188.                 if tabstop not in mirrors:
  189.                     mirrors.append(tabstop)
  190.                 
  191.                 text = text[m.end():]
  192.                 continue
  193.             self.ok = False
  194.             return None
  195.         return mirrors
  196.  
  197.  
  198.  
  199. class PlaceholderMirror(Placeholder):
  200.     
  201.     def __init__(self, view, tabstop, begin):
  202.         Placeholder.__init__(self, view, -1, None, begin)
  203.         self.mirror_stop = tabstop
  204.  
  205.     
  206.     def update(self, mirror):
  207.         self.set_text(mirror.get_text())
  208.         return True
  209.  
  210.     
  211.     def run_last(self, placeholders):
  212.         Placeholder.run_last(self, placeholders)
  213.         if self.mirror_stop in placeholders:
  214.             mirror = placeholders[self.mirror_stop]
  215.             mirror.add_mirror(self)
  216.             if mirror.default:
  217.                 self.set_text(mirror.default)
  218.             
  219.         else:
  220.             self.ok = False
  221.  
  222.  
  223.  
  224. class PlaceholderEnd(Placeholder):
  225.     
  226.     def __init__(self, view, begin, default):
  227.         Placeholder.__init__(self, view, 0, default, begin)
  228.  
  229.     
  230.     def run_last(self, placeholders):
  231.         Placeholder.run_last(self, placeholders)
  232.         if not self.default:
  233.             self.mark_gravity[0] = False
  234.             self.buf.delete_mark(self.begin)
  235.             self.begin = self.buf.create_mark(None, self.end_iter(), self.mark_gravity[0])
  236.         
  237.  
  238.     
  239.     def enter(self):
  240.         if self.begin and not self.begin.get_deleted():
  241.             self.buf.move_mark(self.buf.get_insert(), self.begin_iter())
  242.         
  243.         if self.end and not self.end.get_deleted():
  244.             self.buf.move_mark(self.buf.get_selection_bound(), self.end_iter())
  245.         
  246.  
  247.     
  248.     def leave(self):
  249.         self.enter()
  250.  
  251.  
  252.  
  253. class PlaceholderExpand(Placeholder):
  254.     
  255.     def __init__(self, view, tabstop, begin, s):
  256.         Placeholder.__init__(self, view, tabstop, None, begin)
  257.         self.mirror_text = {
  258.             0: '' }
  259.         self.timeout_id = None
  260.         self.cmd = s
  261.         self.instant_update = False
  262.  
  263.     
  264.     def __str__(self):
  265.         s = Placeholder.__str__(self)
  266.         return s + ' ' + self.cmd
  267.  
  268.     
  269.     def get_mirrors(self, placeholders):
  270.         return self.find_mirrors(self.cmd, placeholders)
  271.  
  272.     
  273.     def run_last(self, placeholders):
  274.         Placeholder.run_last(self, placeholders)
  275.         self.ok = True
  276.         mirrors = self.get_mirrors(placeholders)
  277.         if mirrors:
  278.             allDefault = True
  279.             for mirror in mirrors:
  280.                 p = placeholders[mirror]
  281.                 p.add_mirror(self, not (self.instant_update))
  282.                 self.mirror_text[p.tabstop] = p.default
  283.                 if not (p.default) and not isinstance(p, PlaceholderExpand):
  284.                     allDefault = False
  285.                     continue
  286.             
  287.             if allDefault:
  288.                 self.update(None)
  289.                 if not self.get_text():
  290.                     pass
  291.                 self.default = None
  292.             
  293.         else:
  294.             self.update(None)
  295.             if not self.get_text():
  296.                 pass
  297.             self.default = None
  298.             if self.tabstop == -1:
  299.                 self.done = True
  300.             
  301.  
  302.     
  303.     def re_placeholder(self, m, formatter):
  304.         if m.group(1):
  305.             return '"$' + m.group(2) + '"'
  306.         if m.group(3):
  307.             index = int(m.group(3))
  308.         else:
  309.             index = int(m.group(4))
  310.         return formatter(self.mirror_text[index])
  311.  
  312.     
  313.     def remove_timeout(self):
  314.         if self.timeout_id != None:
  315.             gobject.source_remove(self.timeout_id)
  316.             self.timeout_id = None
  317.         
  318.  
  319.     
  320.     def install_timeout(self):
  321.         self.remove_timeout()
  322.         self.timeout_id = gobject.timeout_add(1000, self.timeout_cb)
  323.  
  324.     
  325.     def timeout_cb(self):
  326.         self.timeout_id = None
  327.         return False
  328.  
  329.     
  330.     def format_environment(self, text):
  331.         return self.literal(text)
  332.  
  333.     
  334.     def substitute(self, text, formatter = None):
  335.         if not formatter:
  336.             pass
  337.         formatter = self.literal
  338.         text = None((re.sub, '(\\\\)?\\$({([0-9]+)}|([0-9]+))'), (lambda m: self.re_placeholder(m, formatter)), text)
  339.         return self.expand_environment(text)
  340.  
  341.     
  342.     def run_update(self):
  343.         text = self.substitute(self.cmd)
  344.         if text:
  345.             ret = self.expand(text)
  346.             if ret:
  347.                 self.update_leave_mirrors()
  348.             
  349.         else:
  350.             ret = True
  351.         return ret
  352.  
  353.     
  354.     def update(self, mirror):
  355.         text = None
  356.         if mirror:
  357.             self.mirror_text[mirror.tabstop] = mirror.get_text()
  358.             for tabstop in self.mirror_text:
  359.                 if tabstop == 0:
  360.                     continue
  361.                 
  362.                 if self.mirror_text[tabstop] == None:
  363.                     return False
  364.             
  365.         
  366.         return self.run_update()
  367.  
  368.     
  369.     def expand(self, text):
  370.         return True
  371.  
  372.  
  373.  
  374. class PlaceholderShell(PlaceholderExpand):
  375.     
  376.     def __init__(self, view, tabstop, begin, s):
  377.         PlaceholderExpand.__init__(self, view, tabstop, begin, s)
  378.         self.shell = None
  379.         self.remove_me = False
  380.  
  381.     
  382.     def close_shell(self):
  383.         self.shell.stdout.close()
  384.         self.shell = None
  385.  
  386.     
  387.     def timeout_cb(self):
  388.         PlaceholderExpand.timeout_cb(self)
  389.         self.remove_timeout()
  390.         if not self.shell:
  391.             return False
  392.         gobject.source_remove(self.watch_id)
  393.         self.close_shell()
  394.         if self.remove_me:
  395.             PlaceholderExpand.remove(self)
  396.         
  397.         message_dialog(None, gtk.MESSAGE_ERROR, 'Execution of the shell command (%s) exceeds the maximum time, execution aborted.' % self.command)
  398.         return False
  399.  
  400.     
  401.     def process_close(self):
  402.         self.close_shell()
  403.         self.remove_timeout()
  404.         self.set_text(str.join('', self.shell_output).rstrip('\n'))
  405.         if self.default == None:
  406.             self.default = self.get_text()
  407.             self.leave()
  408.         
  409.         if self.remove_me:
  410.             PlaceholderExpand.remove(self, True)
  411.         
  412.  
  413.     
  414.     def process_cb(self, source, condition):
  415.         if condition & gobject.IO_IN:
  416.             line = source.readline()
  417.             if len(line) > 0:
  418.                 
  419.                 try:
  420.                     line = unicode(line, 'utf-8')
  421.                 line = unicode(line, locale.getdefaultlocale()[1], 'replace')
  422.  
  423.             
  424.             self.shell_output += line
  425.             self.install_timeout()
  426.             return True
  427.         self.process_close()
  428.         return False
  429.  
  430.     
  431.     def literal(self, text):
  432.         return '"' + re.sub('[\\\\"]', '\\\\\\1', text) + '"'
  433.  
  434.     
  435.     def expand(self, text):
  436.         self.remove_timeout()
  437.         if self.shell:
  438.             gobject.source_remove(self.watch_id)
  439.             self.close_shell()
  440.         
  441.         popen_args = {
  442.             'cwd': None,
  443.             'shell': True,
  444.             'env': os.environ,
  445.             'stdout': subprocess.PIPE }
  446.         self.command = text
  447.         self.shell = subprocess.Popen(text, **popen_args)
  448.         self.shell_output = ''
  449.         self.watch_id = gobject.io_add_watch(self.shell.stdout, gobject.IO_IN | gobject.IO_HUP, self.process_cb)
  450.         self.install_timeout()
  451.         return True
  452.  
  453.     
  454.     def remove(self, force = False):
  455.         if not force and self.shell:
  456.             self.remove_me = True
  457.         elif force:
  458.             self.remove_timeout()
  459.             if self.shell:
  460.                 self.close_shell()
  461.             
  462.         
  463.         PlaceholderExpand.remove(self, force)
  464.  
  465.  
  466.  
  467. class TimeoutError(Exception):
  468.     
  469.     def __init__(self, value):
  470.         self.value = value
  471.  
  472.     
  473.     def __str__(self):
  474.         return repr(self.value)
  475.  
  476.  
  477.  
  478. class PlaceholderEval(PlaceholderExpand):
  479.     
  480.     def __init__(self, view, tabstop, refs, begin, s, namespace):
  481.         PlaceholderExpand.__init__(self, view, tabstop, begin, s)
  482.         self.fdread = 0
  483.         self.remove_me = False
  484.         self.namespace = namespace
  485.         self.refs = []
  486.         if refs:
  487.             for ref in refs:
  488.                 self.refs.append(int(ref.strip()))
  489.             
  490.         
  491.  
  492.     
  493.     def get_mirrors(self, placeholders):
  494.         mirrors = PlaceholderExpand.get_mirrors(self, placeholders)
  495.         if not self.ok:
  496.             return None
  497.         for ref in self.refs:
  498.             if ref in placeholders:
  499.                 if ref not in mirrors:
  500.                     mirrors.append(ref)
  501.                 
  502.             ref not in mirrors
  503.             self.ok = False
  504.             return None
  505.         
  506.         return mirrors
  507.  
  508.     
  509.     def timeout_cb(self, signum = 0, frame = 0):
  510.         raise TimeoutError, 'Operation timed out (>2 seconds)'
  511.  
  512.     
  513.     def install_timeout(self):
  514.         if self.timeout_id != None:
  515.             self.remove_timeout()
  516.         
  517.         self.timeout_id = signal.signal(signal.SIGALRM, self.timeout_cb)
  518.         signal.alarm(2)
  519.  
  520.     
  521.     def remove_timeout(self):
  522.         if self.timeout_id != None:
  523.             signal.alarm(0)
  524.             signal.signal(signal.SIGALRM, self.timeout_id)
  525.             self.timeout_id = None
  526.         
  527.  
  528.     
  529.     def expand(self, text):
  530.         self.remove_timeout()
  531.         text = text.strip()
  532.         self.command = text
  533.         if not (self.command) or self.command == '':
  534.             self.set_text('')
  535.             return None
  536.         text = 'def process_snippet():\n\t' + '\n\t'.join(text.split('\n'))
  537.         if 'process_snippet' in self.namespace:
  538.             del self.namespace['process_snippet']
  539.         
  540.         
  541.         try:
  542.             exec text in self.namespace
  543.         except:
  544.             traceback.print_exc()
  545.  
  546.         if 'process_snippet' in self.namespace:
  547.             
  548.             try:
  549.                 self.install_timeout()
  550.                 result = self.namespace['process_snippet']()
  551.                 self.remove_timeout()
  552.             except TimeoutError:
  553.                 self.remove_timeout()
  554.                 message_dialog(None, gtk.MESSAGE_ERROR, _('Execution of the python command (%s) exceeds the maximum time, execution aborted.') % self.command)
  555.                 return False
  556.                 except Exception:
  557.                     detail = None
  558.                     self.remove_timeout()
  559.                     message_dialog(None, gtk.MESSAGE_ERROR, _('Execution of the python command (%s) failed: %s') % (self.command, detail))
  560.                     return False
  561.                 elif result == None:
  562.                     result = ''
  563.                 
  564.  
  565.             self.set_text(str(result))
  566.         
  567.         return True
  568.  
  569.  
  570.  
  571. class PlaceholderRegex(PlaceholderExpand):
  572.     
  573.     def __init__(self, view, tabstop, begin, inp, pattern, substitution, modifiers):
  574.         PlaceholderExpand.__init__(self, view, tabstop, begin, '')
  575.         self.instant_update = True
  576.         self.inp = inp
  577.         self.pattern = pattern
  578.         self.substitution = substitution
  579.         self.init_modifiers(modifiers)
  580.  
  581.     
  582.     def init_modifiers(self, modifiers):
  583.         mods = {
  584.             'I': re.I,
  585.             'L': re.L,
  586.             'M': re.M,
  587.             'S': re.S,
  588.             'U': re.U,
  589.             'X': re.X }
  590.         self.modifiers = 0
  591.         for modifier in modifiers:
  592.             if modifier in mods:
  593.                 self.modifiers |= mods[modifier]
  594.                 continue
  595.             self
  596.         
  597.  
  598.     
  599.     def get_mirrors(self, placeholders):
  600.         mirrors = self.find_mirrors(self.pattern, placeholders) + self.find_mirrors(self.substitution, placeholders)
  601.         if isinstance(self.inp, int):
  602.             if self.inp not in placeholders:
  603.                 self.ok = False
  604.                 return None
  605.             if self.inp not in mirrors:
  606.                 mirrors.append(self.inp)
  607.             
  608.         
  609.         return mirrors
  610.  
  611.     
  612.     def literal(self, s):
  613.         return re.escape(s)
  614.  
  615.     
  616.     def get_input(self):
  617.         if isinstance(self.inp, int):
  618.             return self.mirror_text[self.inp]
  619.         if self.inp in os.environ:
  620.             return os.environ[self.inp]
  621.         return ''
  622.  
  623.     
  624.     def run_update(self):
  625.         pattern = self.substitute(self.pattern)
  626.         substitution = self.substitute(self.substitution, SubstitutionParser.escape_substitution)
  627.         if pattern:
  628.             return self.expand(pattern, substitution)
  629.         return True
  630.  
  631.     
  632.     def expand(self, pattern, substitution):
  633.         
  634.         try:
  635.             regex = re.compile(pattern, self.modifiers)
  636.         except re.error:
  637.             message = None
  638.             sys.stderr.write('Could not compile regular expression: %s\n%s\n' % (pattern, message))
  639.             return False
  640.  
  641.         inp = self.get_input()
  642.         match = regex.search(inp)
  643.         if not match:
  644.             self.set_text(inp)
  645.         else:
  646.             groups = match.groupdict()
  647.             idx = 0
  648.             for group in match.groups():
  649.                 groups[str(idx + 1)] = group
  650.                 idx += 1
  651.             
  652.             groups['0'] = match.group(0)
  653.             parser = SubstitutionParser(substitution, groups)
  654.             self.set_text(parser.parse())
  655.         return True
  656.  
  657.  
  658.